<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  
  <link rel="shortcut icon" href="../../img/favicon.ico">
  <title>循环层 Recurrent - Keras 中文文档</title>
  <link href='https://fonts.googleapis.com/css?family=Lato:400,700|Roboto+Slab:400,700|Inconsolata:400,700' rel='stylesheet' type='text/css'>

  <link rel="stylesheet" href="../../css/theme.css" type="text/css" />
  <link rel="stylesheet" href="../../css/theme_extra.css" type="text/css" />
  <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css">
  
  <script>
    // Current page data
    var mkdocs_page_name = "\u5faa\u73af\u5c42 Recurrent";
    var mkdocs_page_input_path = "layers/recurrent.md";
    var mkdocs_page_url = "/zh/layers/recurrent/";
  </script>
  
  <script src="../../js/jquery-2.1.1.min.js" defer></script>
  <script src="../../js/modernizr-2.8.3.min.js" defer></script>
  <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
  <script>hljs.initHighlightingOnLoad();</script> 
  
  <script>
      (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
      (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
      m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
      })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

      ga('create', 'UA-61785484-1', 'keras.io');
      ga('send', 'pageview');
  </script>
  
</head>

<body class="wy-body-for-nav" role="document">

  <div class="wy-grid-for-nav">

    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side stickynav">
      <div class="wy-side-nav-search">
        <a href="../.." class="icon icon-home"> Keras 中文文档</a>
        <div role="search">
  <form id ="rtd-search-form" class="wy-form" action="../../search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" title="Type search term here" />
  </form>
</div>
      </div>

      <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
	<ul class="current">
	  
          
            <li class="toctree-l1">
		
    <a class="" href="../..">主页</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../why-use-keras/">为什么选择 Keras?</a>
	    </li>
          
            <li class="toctree-l1">
		
    <span class="caption-text">快速开始</span>
    <ul class="subnav">
                <li class="">
                    
    <a class="" href="../../getting-started/sequential-model-guide/">Sequential 顺序模型指引</a>
                </li>
                <li class="">
                    
    <a class="" href="../../getting-started/functional-api-guide/">函数式 API 指引</a>
                </li>
                <li class="">
                    
    <a class="" href="../../getting-started/faq/">FAQ 常见问题解答</a>
                </li>
    </ul>
	    </li>
          
            <li class="toctree-l1">
		
    <span class="caption-text">模型</span>
    <ul class="subnav">
                <li class="">
                    
    <a class="" href="../../models/about-keras-models/">关于 Keras 模型</a>
                </li>
                <li class="">
                    
    <a class="" href="../../models/sequential/">Sequential 顺序模型 API</a>
                </li>
                <li class="">
                    
    <a class="" href="../../models/model/">函数式 API</a>
                </li>
    </ul>
	    </li>
          
            <li class="toctree-l1">
		
    <span class="caption-text">Layers</span>
    <ul class="subnav">
                <li class="">
                    
    <a class="" href="../about-keras-layers/">关于 Keras 网络层</a>
                </li>
                <li class="">
                    
    <a class="" href="../core/">核心网络层</a>
                </li>
                <li class="">
                    
    <a class="" href="../convolutional/">卷积层 Convolutional</a>
                </li>
                <li class="">
                    
    <a class="" href="../pooling/">池化层 Pooling</a>
                </li>
                <li class="">
                    
    <a class="" href="../local/">局部连接层 Locally-connected</a>
                </li>
                <li class=" current">
                    
    <a class="current" href="./">循环层 Recurrent</a>
    <ul class="subnav">
            
    <li class="toctree-l3"><a href="#rnn">RNN</a></li>
    

    <li class="toctree-l3"><a href="#simplernn">SimpleRNN</a></li>
    

    <li class="toctree-l3"><a href="#gru">GRU</a></li>
    

    <li class="toctree-l3"><a href="#lstm">LSTM</a></li>
    

    <li class="toctree-l3"><a href="#convlstm2d">ConvLSTM2D</a></li>
    

    <li class="toctree-l3"><a href="#simplernncell">SimpleRNNCell</a></li>
    

    <li class="toctree-l3"><a href="#grucell">GRUCell</a></li>
    

    <li class="toctree-l3"><a href="#lstmcell">LSTMCell</a></li>
    

    <li class="toctree-l3"><a href="#cudnngru">CuDNNGRU</a></li>
    

    <li class="toctree-l3"><a href="#cudnnlstm">CuDNNLSTM</a></li>
    

    </ul>
                </li>
                <li class="">
                    
    <a class="" href="../embeddings/">嵌入层 Embedding</a>
                </li>
                <li class="">
                    
    <a class="" href="../merge/">融合层 Merge</a>
                </li>
                <li class="">
                    
    <a class="" href="../advanced-activations/">高级激活层 Advanced Activations</a>
                </li>
                <li class="">
                    
    <a class="" href="../normalization/">标准化层 Normalization</a>
                </li>
                <li class="">
                    
    <a class="" href="../noise/">噪声层 Noise</a>
                </li>
                <li class="">
                    
    <a class="" href="../wrappers/">层封装器 wrappers</a>
                </li>
                <li class="">
                    
    <a class="" href="../writing-your-own-keras-layers/">编写你自己的层</a>
                </li>
    </ul>
	    </li>
          
            <li class="toctree-l1">
		
    <span class="caption-text">数据预处理</span>
    <ul class="subnav">
                <li class="">
                    
    <a class="" href="../../preprocessing/sequence/">序列预处理</a>
                </li>
                <li class="">
                    
    <a class="" href="../../preprocessing/text/">文本预处理</a>
                </li>
                <li class="">
                    
    <a class="" href="../../preprocessing/image/">图像预处理</a>
                </li>
    </ul>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../losses/">损失函数 Losses</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../metrics/">评估标准 Metrics</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../optimizers/">优化器 Optimizers</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../activations/">激活函数 Activations</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../callbacks/">回调函数 Callbacks</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../datasets/">常用数据集 Datasets</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../applications/">应用 Applications</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../backend/">后端 Backend</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../initializers/">初始化 Initializers</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../regularizers/">正则化 Regularizers</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../constraints/">约束 Constraints</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../visualization/">可视化 Visualization</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../scikit-learn-api/">Scikit-learn API</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../utils/">工具</a>
	    </li>
          
            <li class="toctree-l1">
		
    <a class="" href="../../contributing/">贡献</a>
	    </li>
          
            <li class="toctree-l1">
		
    <span class="caption-text">经典样例</span>
    <ul class="subnav">
                <li class="">
                    
    <a class="" href="../../examples/addition_rnn/">Addition RNN</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/babi_rnn/">Baby RNN</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/babi_memnn/">Baby MemNN</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/cifar10_cnn/">CIFAR-10 CNN</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/cifar10_cnn_capsule/">CIFAR-10 CNN-Capsule</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/cifar10_cnn_tfaugment2d/">CIFAR-10 CNN with augmentation (TF)</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/cifar10_resnet/">CIFAR-10 ResNet</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/conv_filter_visualization/">Convolution filter visualization</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/image_ocr/">Image OCR</a>
                </li>
                <li class="">
                    
    <a class="" href="../../examples/imdb_bidirectional_lstm/">Bidirectional LSTM</a>
                </li>
    </ul>
	    </li>
          
        </ul>
      </div>
      &nbsp;
    </nav>

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
        <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
        <a href="../..">Keras 中文文档</a>
      </nav>

      
      <div class="wy-nav-content">
        <div class="rst-content">
          <div role="navigation" aria-label="breadcrumbs navigation">
  <ul class="wy-breadcrumbs">
    <li><a href="../..">Docs</a> &raquo;</li>
    
      
        
          <li>Layers &raquo;</li>
        
      
    
    <li>循环层 Recurrent</li>
    <li class="wy-breadcrumbs-aside">
      
        <a href="https://github.com/keras-team/keras-docs-zh/edit/master/docs/layers/recurrent.md"
          class="icon icon-github"> Edit on GitHub</a>
      
    </li>
  </ul>
  <hr/>
</div>
          <div role="main">
            <div class="section">
              
                <p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/recurrent.py#L237">[source]</a></span></p>
<h3 id="rnn">RNN</h3>
<pre><code class="python">keras.layers.RNN(cell, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)
</code></pre>

<p>循环神经网络层基类。</p>
<p><strong>参数</strong></p>
<ul>
<li>
<p><strong>cell</strong>: 一个 RNN 单元实例。RNN 单元是一个具有以下几项的类：</p>
<ul>
<li>一个 <code>call(input_at_t, states_at_t)</code> 方法，
  它返回 <code>(output_at_t, states_at_t_plus_1)</code>。
  单元的调用方法也可以采引入可选参数 <code>constants</code>，
  详见下面的小节「关于给 RNN 传递外部常量的说明」。</li>
<li>一个 <code>state_size</code> 属性。这可以是单个整数（单个状态），
  在这种情况下，它是循环层状态的大小（应该与单元输出的大小相同）。
  这也可以是整数表示的列表/元组（每个状态一个大小）。</li>
<li>一个 <code>output_size</code> 属性。 这可以是单个整数或者是一个 TensorShape，
  它表示输出的尺寸。出于向后兼容的原因，如果此属性对于当前单元不可用，
  则该值将由 <code>state_size</code> 的第一个元素推断。</li>
</ul>
<p><code>cell</code> 也可能是 RNN 单元实例的列表，在这种情况下，RNN 的单元将堆叠在另一个单元上，实现高效的堆叠 RNN。</p>
</li>
<li>
<p><strong>return_sequences</strong>: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。</p>
</li>
<li><strong>return_state</strong>: 布尔值。除了输出之外是否返回最后一个状态。</li>
<li><strong>go_backwards</strong>: 布尔值 (默认 False)。
如果为 True，则向后处理输入序列并返回相反的序列。</li>
<li><strong>stateful</strong>: 布尔值 (默认 False)。
如果为 True，则批次中索引 i 处的每个样品的最后状态将用作下一批次中索引 i 样品的初始状态。</li>
<li><strong>unroll</strong>: 布尔值 (默认 False)。
如果为 True，则网络将展开，否则将使用符号循环。
展开可以加速 RNN，但它往往会占用更多的内存。
展开只适用于短序列。</li>
<li><strong>input_dim</strong>: 输入的维度（整数）。
将此层用作模型中的第一层时，此参数（或者，关键字参数 <code>input_shape</code>）是必需的。</li>
<li><strong>input_length</strong>: 输入序列的长度，在恒定时指定。
如果你要在上游连接 <code>Flatten</code> 和 <code>Dense</code> 层，
则需要此参数（如果没有它，无法计算全连接输出的尺寸）。
请注意，如果循环神经网络层不是模型中的第一层，
则需要在第一层的层级指定输入长度（例如，通过 <code>input_shape</code> 参数）。</li>
</ul>
<p><strong>输入尺寸</strong></p>
<p>3D 张量，尺寸为 <code>(batch_size, timesteps, input_dim)</code>。</p>
<p><strong>输出尺寸</strong></p>
<ul>
<li>如果 <code>return_state</code>：返回张量列表。
第一个张量为输出。剩余的张量为最后的状态，
每个张量的尺寸为 <code>(batch_size, units)</code>。</li>
<li>如果 <code>return_sequences</code>：返回 3D 张量，
尺寸为 <code>(batch_size, timesteps, units)</code>。</li>
<li>否则，返回尺寸为 <code>(batch_size, units)</code> 的 2D 张量。</li>
</ul>
<p><strong>Masking</strong></p>
<p>该层支持以可变数量的时间步对输入数据进行 masking。
要将 masking 引入你的数据，请使用 <a href="../embeddings/">Embedding</a> 层，
并将 <code>mask_zero</code> 参数设置为 <code>True</code>。</p>
<p><strong>关于在 RNN 中使用「状态（statefulness）」的说明</strong></p>
<p>你可以将 RNN 层设置为 <code>stateful</code>（有状态的），
这意味着针对一个批次的样本计算的状态将被重新用作下一批样本的初始状态。
这假定在不同连续批次的样品之间有一对一的映射。</p>
<p>为了使状态有效：</p>
<ul>
<li>在层构造器中指定 <code>stateful=True</code>。</li>
<li>为你的模型指定一个固定的批次大小，
如果是顺序模型，为你的模型的第一层传递一个 <code>batch_input_shape=(...)</code> 参数。</li>
<li>为你的模型指定一个固定的批次大小，
如果是顺序模型，为你的模型的第一层传递一个 <code>batch_input_shape=(...)</code>。
如果是带有 1 个或多个 Input 层的函数式模型，为你的模型的所有第一层传递一个 <code>batch_shape=(...)</code>。
这是你的输入的预期尺寸，<em>包括批量维度</em>。
它应该是整数的元组，例如 <code>(32, 10, 100)</code>。</li>
<li>在调用 <code>fit()</code> 是指定 <code>shuffle=False</code>。</li>
</ul>
<p>要重置模型的状态，请在特定图层或整个模型上调用 <code>.reset_states()</code>。</p>
<p><strong>关于指定 RNN 初始状态的说明</strong></p>
<p>您可以通过使用关键字参数 <code>initial_state</code> 调用它们来符号化地指定 RNN 层的初始状态。
<code>initial_state</code> 的值应该是表示 RNN 层初始状态的张量或张量列表。</p>
<p>您可以通过调用带有关键字参数 <code>states</code> 的 <code>reset_states</code> 方法来数字化地指定 RNN 层的初始状态。
<code>states</code> 的值应该是一个代表 RNN 层初始状态的 Numpy 数组或者 Numpy 数组列表。</p>
<p><strong>关于给 RNN 传递外部常量的说明</strong></p>
<p>你可以使用 <code>RNN.__call__</code>（以及 <code>RNN.call</code>）的 <code>constants</code> 关键字参数将「外部」常量传递给单元。
这要求 <code>cell.call</code> 方法接受相同的关键字参数 <code>constants</code>。
这些常数可用于调节附加静态输入（不随时间变化）上的单元转换，也可用于注意力机制。</p>
<p><strong>例子</strong></p>
<pre><code class="python"># 首先，让我们定义一个 RNN 单元，作为网络层子类。

class MinimalRNNCell(keras.layers.Layer):

    def __init__(self, units, **kwargs):
        self.units = units
        self.state_size = units
        super(MinimalRNNCell, self).__init__(**kwargs)

    def build(self, input_shape):
        self.kernel = self.add_weight(shape=(input_shape[-1], self.units),
                                      initializer='uniform',
                                      name='kernel')
        self.recurrent_kernel = self.add_weight(
            shape=(self.units, self.units),
            initializer='uniform',
            name='recurrent_kernel')
        self.built = True

    def call(self, inputs, states):
        prev_output = states[0]
        h = K.dot(inputs, self.kernel)
        output = h + K.dot(prev_output, self.recurrent_kernel)
        return output, [output]

# 让我们在 RNN 层使用这个单元：

cell = MinimalRNNCell(32)
x = keras.Input((None, 5))
layer = RNN(cell)
y = layer(x)

# 以下是如何使用单元格构建堆叠的 RNN的方法：

cells = [MinimalRNNCell(32), MinimalRNNCell(64)]
x = keras.Input((None, 5))
layer = RNN(cells)
y = layer(x)
</code></pre>

<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/recurrent.py#L944">[source]</a></span></p>
<h3 id="simplernn">SimpleRNN</h3>
<pre><code class="python">keras.layers.SimpleRNN(units, activation='tanh', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)
</code></pre>

<p>全连接的 RNN，其输出将被反馈到输入。</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>units</strong>: 正整数，输出空间的维度。</li>
<li><strong>activation</strong>: 要使用的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：双曲正切（<code>tanh</code>）。
如果传入 <code>None</code>，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>use_bias</strong>: 布尔值，该层是否使用偏置向量。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>activity_regularizer</strong>: 运用到层输出（它的激活值）的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于输入的线性转换。</li>
<li><strong>recurrent_dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于循环层状态的线性转换。</li>
<li><strong>return_sequences</strong>: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。</li>
<li><strong>return_state</strong>: 布尔值。除了输出之外是否返回最后一个状态。</li>
<li><strong>go_backwards</strong>: 布尔值 (默认 False)。
如果为 True，则向后处理输入序列并返回相反的序列。</li>
<li><strong>stateful</strong>: 布尔值 (默认 False)。
如果为 True，则批次中索引 i 处的每个样品
的最后状态将用作下一批次中索引 i 样品的初始状态。</li>
<li><strong>unroll</strong>: 布尔值 (默认 False)。
如果为 True，则网络将展开，否则将使用符号循环。
展开可以加速 RNN，但它往往会占用更多的内存。
展开只适用于短序列。</li>
</ul>
<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/recurrent.py#L1482">[source]</a></span></p>
<h3 id="gru">GRU</h3>
<pre><code class="python">keras.layers.GRU(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False, reset_after=False)
</code></pre>

<p>门限循环单元网络（Gated Recurrent Unit） - Cho et al. 2014.</p>
<p>有两种变体。默认的是基于 1406.1078v3 的实现，同时在矩阵乘法之前将复位门应用于隐藏状态。
另一种则是基于 1406.1078v1 的实现，它包括顺序倒置的操作。</p>
<p>第二种变体与 CuDNNGRU(GPU-only) 兼容并且允许在 CPU 上进行推理。
因此它对于 <code>kernel</code> 和 <code>recurrent_kernel</code> 有可分离偏置。
使用 <code>'reset_after'=True</code> 和 <code>recurrent_activation='sigmoid'</code> 。</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>units</strong>: 正整数，输出空间的维度。</li>
<li><strong>activation</strong>: 要使用的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：双曲正切 (<code>tanh</code>)。
如果传入 <code>None</code>，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>recurrent_activation</strong>: 用于循环时间步的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：分段线性近似 sigmoid (<code>hard_sigmoid</code>)。
如果传入 None，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>use_bias</strong>: 布尔值，该层是否使用偏置向量。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>activity_regularizer</strong>: 运用到层输出（它的激活值）的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于输入的线性转换。</li>
<li><strong>recurrent_dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于循环层状态的线性转换。</li>
<li><strong>implementation</strong>: 实现模式，1 或 2。
模式 1 将把它的操作结构化为更多的小的点积和加法操作，
而模式 2 将把它们分批到更少，更大的操作中。
这些模式在不同的硬件和不同的应用中具有不同的性能配置文件。</li>
<li><strong>return_sequences</strong>: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。</li>
<li><strong>return_state</strong>: 布尔值。除了输出之外是否返回最后一个状态。</li>
<li><strong>go_backwards</strong>: 布尔值 (默认 False)。
如果为 True，则向后处理输入序列并返回相反的序列。</li>
<li><strong>stateful</strong>: 布尔值 (默认 False)。
如果为 True，则批次中索引 i 处的每个样品的最后状态
将用作下一批次中索引 i 样品的初始状态。</li>
<li><strong>unroll</strong>: 布尔值 (默认 False)。
如果为 True，则网络将展开，否则将使用符号循环。
展开可以加速 RNN，但它往往会占用更多的内存。
展开只适用于短序列。</li>
<li><strong>reset_after</strong>: </li>
<li>GRU 公约 (是否在矩阵乘法之前或者之后使用重置门)。
False =「之前」(默认)，Ture =「之后」( CuDNN 兼容)。</li>
</ul>
<p><strong>参考文献</strong></p>
<ul>
<li><a href="https://arxiv.org/abs/1406.1078">Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation</a></li>
<li><a href="https://arxiv.org/abs/1409.1259">On the Properties of Neural Machine Translation: Encoder-Decoder Approaches</a></li>
<li><a href="http://arxiv.org/abs/1412.3555v1">Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling</a></li>
<li><a href="http://arxiv.org/abs/1512.05287">A Theoretically Grounded Application of Dropout in Recurrent Neural Networks</a></li>
</ul>
<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/recurrent.py#L2034">[source]</a></span></p>
<h3 id="lstm">LSTM</h3>
<pre><code class="python">keras.layers.LSTM(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)
</code></pre>

<p>长短期记忆网络层（Long Short-Term Memory） - Hochreiter 1997.</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>units</strong>: 正整数，输出空间的维度。</li>
<li><strong>activation</strong>: 要使用的激活函数
(详见 <a href="../../activations/">activations</a>)。
如果传入 <code>None</code>，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>recurrent_activation</strong>: 用于循环时间步的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：分段线性近似 sigmoid (<code>hard_sigmoid</code>)。
如果传入 <code>None</code>，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>use_bias</strong>: 布尔值，该层是否使用偏置向量。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>unit_forget_bias</strong>: 布尔值。
如果为 True，初始化时，将忘记门的偏置加 1。
将其设置为 True 同时还会强制 <code>bias_initializer="zeros"</code>。
这个建议来自 <a href="http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf">Jozefowicz et al.</a>。</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>activity_regularizer</strong>: 运用到层输出（它的激活值）的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于输入的线性转换。</li>
<li><strong>recurrent_dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于循环层状态的线性转换。</li>
<li><strong>implementation</strong>: 实现模式，1 或 2。
模式 1 将把它的操作结构化为更多的小的点积和加法操作，
而模式 2 将把它们分批到更少，更大的操作中。
这些模式在不同的硬件和不同的应用中具有不同的性能配置文件。</li>
<li><strong>return_sequences</strong>: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。</li>
<li><strong>return_state</strong>: 布尔值。除了输出之外是否返回最后一个状态。</li>
<li><strong>go_backwards</strong>: 布尔值 (默认 False)。
如果为 True，则向后处理输入序列并返回相反的序列。</li>
<li><strong>stateful</strong>: 布尔值 (默认 False)。
如果为 True，则批次中索引 i 处的每个样品的最后状态
将用作下一批次中索引 i 样品的初始状态。</li>
<li><strong>unroll</strong>: 布尔值 (默认 False)。
如果为 True，则网络将展开，否则将使用符号循环。
展开可以加速 RNN，但它往往会占用更多的内存。
展开只适用于短序列。</li>
</ul>
<p><strong>参考文献</strong></p>
<ul>
<li><a href="http://www.bioinf.jku.at/publications/older/2604.pdf">Long short-term memory</a> (original 1997 paper)</li>
<li><a href="http://www.mitpressjournals.org/doi/pdf/10.1162/089976600300015015">Learning to forget: Continual prediction with LSTM</a></li>
<li><a href="http://www.cs.toronto.edu/~graves/preprint.pdf">Supervised sequence labeling with recurrent neural networks</a></li>
<li><a href="http://arxiv.org/abs/1512.05287">A Theoretically Grounded Application of Dropout in Recurrent Neural Networks</a></li>
</ul>
<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/convolutional_recurrent.py#L788">[source]</a></span></p>
<h3 id="convlstm2d">ConvLSTM2D</h3>
<pre><code class="python">keras.layers.ConvLSTM2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, return_sequences=False, go_backwards=False, stateful=False, dropout=0.0, recurrent_dropout=0.0)
</code></pre>

<p>卷积 LSTM。</p>
<p>它类似于 LSTM 层，但输入变换和循环变换都是卷积的。</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>filters</strong>: 整数，输出空间的维度
（即卷积中滤波器的输出数量）。</li>
<li><strong>kernel_size</strong>: 一个整数，或者 n 个整数表示的元组或列表，
指明卷积窗口的维度。</li>
<li><strong>strides</strong>: 一个整数，或者 n 个整数表示的元组或列表，
指明卷积的步长。
指定任何 stride 值 != 1 与指定 <code>dilation_rate</code> 值 != 1 两者不兼容。</li>
<li><strong>padding</strong>: <code>"valid"</code> 或 <code>"same"</code> 之一 (大小写敏感)。</li>
<li><strong>data_format</strong>: 字符串，
<code>channels_last</code> (默认) 或 <code>channels_first</code> 之一。
输入中维度的顺序。
<code>channels_last</code> 对应输入尺寸为 <code>(batch, time, ..., channels)</code>，
<code>channels_first</code> 对应输入尺寸为 <code>(batch, time, channels, ...)</code>。
它默认为从 Keras 配置文件 <code>~/.keras/keras.json</code> 中
找到的 <code>image_data_format</code> 值。
如果你从未设置它，将使用 <code>"channels_last"</code>。</li>
<li><strong>dilation_rate</strong>: 一个整数，或 n 个整数的元组/列表，指定用于膨胀卷积的膨胀率。
目前，指定任何 <code>dilation_rate</code> 值 != 1 与指定 stride 值 != 1 两者不兼容。</li>
<li><strong>activation</strong>: 要使用的激活函数
(详见 <a href="../../activations/">activations</a>)。
如果传入 None，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>recurrent_activation</strong>: 用于循环时间步的激活函数
(详见 <a href="../../activations/">activations</a>)。</li>
<li><strong>use_bias</strong>: 布尔值，该层是否使用偏置向量。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>unit_forget_bias</strong>: 布尔值。
如果为 True，初始化时，将忘记门的偏置加 1。
将其设置为 True 同时还会强制 <code>bias_initializer="zeros"</code>。
这个建议来自 <a href="http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf">Jozefowicz et al.</a>。</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>activity_regularizer</strong>: 运用到层输出（它的激活值）的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>return_sequences</strong>: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。</li>
<li><strong>go_backwards</strong>: 布尔值 (默认 False)。
如果为 True，则向后处理输入序列并返回相反的序列。</li>
<li><strong>stateful</strong>: 布尔值 (默认 False)。
如果为 True，则批次中索引 i 处的每个样品的最后状态
将用作下一批次中索引 i 样品的初始状态。</li>
<li><strong>dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于输入的线性转换。</li>
<li><strong>recurrent_dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于循环层状态的线性转换。</li>
</ul>
<p><strong>输入尺寸</strong></p>
<ul>
<li>如果 data_format='channels_first'，
输入 5D 张量，尺寸为：
<code>(samples,time, channels, rows, cols)</code>。</li>
<li>如果 data_format='channels_last'，
输入 5D 张量，尺寸为：
<code>(samples,time, rows, cols, channels)</code>。</li>
</ul>
<p><strong>输出尺寸</strong></p>
<ul>
<li>如果 <code>return_sequences</code>，<ul>
<li>如果 data_format='channels_first'，返回 5D 张量，尺寸为：<code>(samples, time, filters, output_row, output_col)</code>。</li>
<li>如果 data_format='channels_last'，返回 5D 张量，尺寸为：<code>(samples, time, output_row, output_col, filters)</code>。</li>
</ul>
</li>
<li>否则，<ul>
<li>如果 data_format ='channels_first'，返回 4D 张量，尺寸为：<code>(samples, filters, output_row, output_col)</code>。</li>
<li>如果 data_format='channels_last'，返回 4D 张量，尺寸为：<code>(samples, output_row, output_col, filters)</code>。</li>
</ul>
</li>
</ul>
<p>o_row 和 o_col 取决于 filter 和 padding 的尺寸。</p>
<p><strong>异常</strong></p>
<ul>
<li><strong>ValueError</strong>: 无效的构造参数。</li>
</ul>
<p><strong>参考文献</strong></p>
<ul>
<li><a href="http://arxiv.org/abs/1506.04214v1">Convolutional LSTM Network: A Machine Learning Approach for
Precipitation Nowcasting</a>。
当前的实现不包括单元输出的反馈回路。</li>
</ul>
<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/recurrent.py#L779">[source]</a></span></p>
<h3 id="simplernncell">SimpleRNNCell</h3>
<pre><code class="python">keras.layers.SimpleRNNCell(units, activation='tanh', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0)
</code></pre>

<p>SimpleRNN 的单元类。</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>units</strong>: 正整数，输出空间的维度。</li>
<li><strong>activation</strong>: 要使用的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：双曲正切 (<code>tanh</code>)。
如果传入 <code>None</code>，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>use_bias</strong>: 布尔值，该层是否使用偏置向量。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于输入的线性转换。</li>
<li><strong>recurrent_dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于循环层状态的线性转换。</li>
</ul>
<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/recurrent.py#L1163">[source]</a></span></p>
<h3 id="grucell">GRUCell</h3>
<pre><code class="python">keras.layers.GRUCell(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1, reset_after=False)
</code></pre>

<p>GRU 层的单元类。</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>units</strong>: 正整数，输出空间的维度。</li>
<li><strong>activation</strong>: 要使用的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：双曲正切 (<code>tanh</code>)。
如果传入 <code>None</code>，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>recurrent_activation</strong>: 用于循环时间步的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：分段线性近似 sigmoid (<code>hard_sigmoid</code>)。
如果传入 <code>None</code>，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>use_bias</strong>: 布尔值，该层是否使用偏置向量。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于输入的线性转换。</li>
<li><strong>recurrent_dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于循环层状态的线性转换。</li>
<li><strong>implementation</strong>: 实现模式，1 或 2。
模式 1 将把它的操作结构化为更多的小的点积和加法操作，
而模式 2 将把它们分批到更少，更大的操作中。
这些模式在不同的硬件和不同的应用中具有不同的性能配置文件。</li>
<li><strong>reset_after</strong>: </li>
<li>GRU 公约 (是否在矩阵乘法之前或者之后使用重置门)。
False = "before" (默认)，Ture = "after" ( CuDNN 兼容)。</li>
<li><strong>reset_after</strong>: GRU convention (whether to apply reset gate after or
before matrix multiplication). False = "before" (default),
True = "after" (CuDNN compatible).</li>
</ul>
<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/recurrent.py#L1756">[source]</a></span></p>
<h3 id="lstmcell">LSTMCell</h3>
<pre><code class="python">keras.layers.LSTMCell(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1)
</code></pre>

<p>LSTM 层的单元类。</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>units</strong>: 正整数，输出空间的维度。</li>
<li><strong>activation</strong>: 要使用的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：双曲正切（<code>tanh</code>）。
如果传入 <code>None</code>，则不使用激活函数
(即 线性激活：<code>a(x) = x</code>)。</li>
<li><strong>recurrent_activation</strong>: 用于循环时间步的激活函数
(详见 <a href="../../activations/">activations</a>)。
默认：分段线性近似 sigmoid (<code>hard_sigmoid</code>)。</li>
<li><strong>use_bias</strong>: 布尔值，该层是否使用偏置向量。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>unit_forget_bias</strong>: 布尔值。
如果为 True，初始化时，将忘记门的偏置加 1。
将其设置为 True 同时还会强制 <code>bias_initializer="zeros"</code>。
这个建议来自 <a href="http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf">Jozefowicz et al.</a>。</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于输入的线性转换。</li>
<li><strong>recurrent_dropout</strong>: 在 0 和 1 之间的浮点数。
单元的丢弃比例，用于循环层状态的线性转换。</li>
<li><strong>implementation</strong>: 实现模式，1 或 2。
模式 1 将把它的操作结构化为更多的小的点积和加法操作，
而模式 2 将把它们分批到更少，更大的操作中。
这些模式在不同的硬件和不同的应用中具有不同的性能配置文件。</li>
</ul>
<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/cudnn_recurrent.py#L135">[source]</a></span></p>
<h3 id="cudnngru">CuDNNGRU</h3>
<pre><code class="python">keras.layers.CuDNNGRU(units, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, return_sequences=False, return_state=False, stateful=False)
</code></pre>

<p>由 <a href="https://developer.nvidia.com/cudnn">CuDNN</a> 支持的快速 GRU 实现。</p>
<p>只能以 TensorFlow 后端运行在 GPU 上。</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>units</strong>: 正整数，输出空间的维度。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>activity_regularizer</strong>: Regularizer function applied to
the output of the layer (its "activation").
(see <a href="../../regularizers/">regularizer</a>).</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>return_sequences</strong>: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。</li>
<li><strong>return_state</strong>: 布尔值。除了输出之外是否返回最后一个状态。</li>
<li><strong>stateful</strong>: 布尔值 (默认 False)。
如果为 True，则批次中索引 i 处的每个样品的最后状态
将用作下一批次中索引 i 样品的初始状态。</li>
</ul>
<hr />
<p><span style="float:right;"><a href="https://github.com/keras-team/keras/blob/master/keras/layers/cudnn_recurrent.py#L328">[source]</a></span></p>
<h3 id="cudnnlstm">CuDNNLSTM</h3>
<pre><code class="python">keras.layers.CuDNNLSTM(units, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, return_sequences=False, return_state=False, stateful=False)
</code></pre>

<p>由 <a href="https://developer.nvidia.com/cudnn">CuDNN</a> 支持的快速 LSTM 实现。</p>
<p>只能以 TensorFlow 后端运行在 GPU 上。</p>
<p><strong>参数</strong></p>
<ul>
<li><strong>units</strong>: 正整数，输出空间的维度。</li>
<li><strong>kernel_initializer</strong>: <code>kernel</code> 权值矩阵的初始化器，
用于输入的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>unit_forget_bias</strong>: 布尔值。
如果为 True，初始化时，将忘记门的偏置加 1。
将其设置为 True 同时还会强制 <code>bias_initializer="zeros"</code>。
这个建议来自 <a href="http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf">Jozefowicz et al.</a>。</li>
<li><strong>recurrent_initializer</strong>: <code>recurrent_kernel</code> 权值矩阵
的初始化器，用于循环层状态的线性转换
(详见 <a href="../../initializers/">initializers</a>)。</li>
<li><strong>bias_initializer</strong>:偏置向量的初始化器
(详见<a href="../../initializers/">initializers</a>).</li>
<li><strong>kernel_regularizer</strong>: 运用到 <code>kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>recurrent_regularizer</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>bias_regularizer</strong>: 运用到偏置向量的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>activity_regularizer</strong>: 运用到层输出（它的激活值）的正则化函数
(详见 <a href="../../regularizers/">regularizer</a>)。</li>
<li><strong>kernel_constraint</strong>: 运用到 <code>kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>recurrent_constraint</strong>: 运用到 <code>recurrent_kernel</code> 权值矩阵的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>bias_constraint</strong>: 运用到偏置向量的约束函数
(详见 <a href="../../constraints/">constraints</a>)。</li>
<li><strong>return_sequences</strong>: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。</li>
<li><strong>return_state</strong>: 布尔值。除了输出之外是否返回最后一个状态。</li>
<li><strong>stateful</strong>: 布尔值 (默认 False)。
如果为 True，则批次中索引 i 处的每个样品的最后状态
将用作下一批次中索引 i 样品的初始状态。</li>
</ul>
              
            </div>
          </div>
          <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="../embeddings/" class="btn btn-neutral float-right" title="嵌入层 Embedding">Next <span class="icon icon-circle-arrow-right"></span></a>
      
      
        <a href="../local/" class="btn btn-neutral" title="局部连接层 Locally-connected"><span class="icon icon-circle-arrow-left"></span> Previous</a>
      
    </div>
  

  <hr/>

  <div role="contentinfo">
    <!-- Copyright etc -->
    
  </div>

  Built with <a href="http://www.mkdocs.org">MkDocs</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>.
</footer>
      
        </div>
      </div>

    </section>

  </div>

  <div class="rst-versions" role="note" style="cursor: pointer">
    <span class="rst-current-version" data-toggle="rst-current-version">
      
          <a href="https://github.com/keras-team/keras-docs-zh/" class="fa fa-github" style="float: left; color: #fcfcfc"> GitHub</a>
      
      
        <span><a href="../local/" style="color: #fcfcfc;">&laquo; Previous</a></span>
      
      
        <span style="margin-left: 15px"><a href="../embeddings/" style="color: #fcfcfc">Next &raquo;</a></span>
      
    </span>
</div>
    <script>var base_url = '../..';</script>
    <script src="../../js/theme.js" defer></script>
      <script src="../../search/main.js" defer></script>

</body>
</html>
